package com.dimples.dd.redis.core;

import cn.hutool.core.util.StrUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * 定义常用的 Redis操作
 *
 * @author zhongyj <1126834403@qq.com><br/>
 * @date 2024/6/17
 */
@SuppressWarnings("ALL")
public class RedisHelper {

    private StringRedisTemplate stringRedisTemplate;
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Autowired
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }


    public void set(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    public Object get(String key) {
        return key == null ? null : this.redisTemplate.opsForValue().get(key);
    }

    public void convertAndSend(String channel, Object message) {
        redisTemplate.convertAndSend(channel, message);
    }


    // -------------------key相关操作--------------------- //

    /**
     * 删除key
     *
     * @param key String
     */
    public void strDelete(String key) {
        stringRedisTemplate.delete(key);
    }

    /**
     * 批量删除key
     *
     * @param keys Collection<String>
     */
    public void strDelete(Collection<String> keys) {
        stringRedisTemplate.delete(keys);
    }

    /**
     * 序列化key
     *
     * @param key stringh
     * @return byte[]
     */
    public byte[] strDump(String key) {
        return stringRedisTemplate.dump(key);
    }

    /**
     * 是否存在key
     *
     * @param key String
     * @return Boolean
     */
    public Boolean strHasKey(String key) {
        return stringRedisTemplate.hasKey(key);
    }

    /**
     * 是否存在key并且值为true
     *
     * @param keyString String
     * @return boolean
     */
    public boolean strExistTrue(String keyString) {
        return this.strHasKey(keyString) && StrUtil.equalsIgnoreCase(this.strGet(keyString), "true");
    }

    /**
     * 设置过期时间
     *
     * @param key     String
     * @param timeout long
     * @param unit    TimeUnit
     * @return Boolean
     */
    public Boolean strExpire(String key, long timeout, TimeUnit unit) {
        return stringRedisTemplate.expire(key, timeout, unit);
    }

    /**
     * 设置过期时间
     *
     * @param key  String
     * @param date Date
     * @return Boolean
     */
    public Boolean strExpireAt(String key, Date date) {
        return stringRedisTemplate.expireAt(key, date);
    }

    /**
     * 查找匹配的key
     *
     * @param pattern String
     * @return Set<String>
     */
    public Set<String> strKeys(String pattern) {
        return stringRedisTemplate.keys(pattern);
    }

    /**
     * 将当前数据库的 key 移动到给定的数据库 db 当中
     *
     * @param key     String
     * @param dbIndex int
     * @return Boolean
     */
    public Boolean strMove(String key, int dbIndex) {
        return stringRedisTemplate.move(key, dbIndex);
    }

    /**
     * 移除 key 的过期时间，key 将持久保持
     *
     * @param key String
     * @return Boolean
     */
    public Boolean strPersist(String key) {
        return stringRedisTemplate.persist(key);
    }

    /**
     * 返回 key 的剩余的过期时间
     *
     * @param key  String
     * @param unit TimeUnit
     * @return Long
     */
    public Long strGetExpire(String key, TimeUnit unit) {
        return stringRedisTemplate.getExpire(key, unit);
    }

    /**
     * 返回 key 的剩余的过期时间
     *
     * @param key String
     * @return Long
     */
    public Long strGetExpire(String key) {
        return stringRedisTemplate.getExpire(key);
    }

    /**
     * 从当前数据库中随机返回一个 key
     *
     * @return String
     */
    public String strRandomKey() {
        return stringRedisTemplate.randomKey();
    }

    /**
     * 修改 key 的名称
     *
     * @param oldKey String
     * @param newKey String
     */
    public void strRename(String oldKey, String newKey) {
        stringRedisTemplate.rename(oldKey, newKey);
    }

    /**
     * 仅当 newkey 不存在时，将 oldKey 改名为 newkey
     *
     * @param oldKey String
     * @param newKey String
     * @return Boolean
     */
    public Boolean strRenameIfAbsent(String oldKey, String newKey) {
        return stringRedisTemplate.renameIfAbsent(oldKey, newKey);
    }

    /**
     * 返回 key 所储存的值的类型
     *
     * @param key String
     * @return DataType
     */
    public DataType strType(String key) {
        return stringRedisTemplate.type(key);
    }

    // -------------------string相关操作--------------------- //

    /**
     * 设置指定 key 的值
     *
     * @param key   String
     * @param value String
     */
    public void strSet(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    /**
     * 获取指定 key 的值
     *
     * @param key String
     * @return String
     */
    public String strGet(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 返回 key 中字符串值的子字符
     *
     * @param key   String
     * @param start long
     * @param end   long
     * @return String
     */
    public String strGetRange(String key, long start, long end) {
        return stringRedisTemplate.opsForValue().get(key, start, end);
    }

    /**
     * 将给定 key 的值设为 value ，并返回 key 的旧值(old value)
     *
     * @param key   String
     * @param value String
     * @return String
     */
    public String strGetAndSet(String key, String value) {
        return stringRedisTemplate.opsForValue().getAndSet(key, value);
    }

    /**
     * 对 key 所储存的字符串值，获取指定偏移量上的位(bit)
     *
     * @param key    String
     * @param offset long
     * @return Boolean
     */
    public Boolean strGetBit(String key, long offset) {
        return stringRedisTemplate.opsForValue().getBit(key, offset);
    }

    /**
     * 批量获取
     *
     * @param keys Collection<String>
     * @return List<String>
     */
    public List<String> strMultiGet(Collection<String> keys) {
        return stringRedisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value
     *
     * @param key   位置
     * @param value 值,true为1, false为0
     * @return boolean
     */
    @SuppressWarnings("all")
    public boolean strSetBit(String key, long offset, boolean value) {
        return stringRedisTemplate.opsForValue().setBit(key, offset, value);
    }

    /**
     * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
     *
     * @param key     String
     * @param value   String
     * @param timeout 过期时间
     * @param unit    时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
     *                秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
     */
    public void strSetEx(String key, String value, long timeout, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 只有在 key 不存在时设置 key 的值
     *
     * @param key   String
     * @param value String
     * @return 之前已经存在返回false, 不存在返回true
     */
    public boolean strSetIfAbsent(String key, String value) {
        return stringRedisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始
     *
     * @param key    String
     * @param value  String
     * @param offset 从指定位置开始覆写
     */
    public void strSetRange(String key, String value, long offset) {
        stringRedisTemplate.opsForValue().set(key, value, offset);
    }

    /**
     * 获取字符串的长度
     *
     * @param key String
     * @return Long
     */
    public Long strSize(String key) {
        return stringRedisTemplate.opsForValue().size(key);
    }

    /**
     * 批量添加
     *
     * @param maps Map<String, String>
     */
    public void strMultiSet(Map<String, String> maps) {
        stringRedisTemplate.opsForValue().multiSet(maps);
    }

    /**
     * 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在
     *
     * @param maps Map<String, String>
     * @return 之前已经存在返回false, 不存在返回true
     */
    @SuppressWarnings("all")
    public boolean strMultiSetIfAbsent(Map<String, String> maps) {
        return stringRedisTemplate.opsForValue().multiSetIfAbsent(maps);
    }

    /**
     * 增加(自增长), 负数则为自减
     *
     * @param key String
     * @return long
     */
    public Long strIncrBy(String key, long increment) {
        return stringRedisTemplate.opsForValue().increment(key, increment);
    }

    /**
     * @param key String
     * @return double
     */
    public Double strIncrByFloat(String key, double increment) {
        return stringRedisTemplate.opsForValue().increment(key, increment);
    }

    /**
     * 追加到末尾
     *
     * @param key   String
     * @param value String
     * @return Integer
     */
    public Integer strAppend(String key, String value) {
        return stringRedisTemplate.opsForValue().append(key, value);
    }

    // -------------------hash相关操作------------------------- //

    /**
     * 获取存储在哈希表中指定字段的值
     *
     * @param key   String
     * @param field String
     * @return Object
     */
    public Object strHGet(String key, String field) {
        return stringRedisTemplate.opsForHash().get(key, field);
    }

    /**
     * 获取所有给定字段的值
     *
     * @param key String
     * @return Map<Object, Object>
     */
    public Map<Object, Object> strHGetAll(String key) {
        return stringRedisTemplate.opsForHash().entries(key);
    }

    /**
     * 获取所有给定字段的值
     *
     * @param key    String
     * @param fields Collection<Object>
     * @return List<Object>
     */
    public List<Object> strHMultiGet(String key, Collection<Object> fields) {
        return stringRedisTemplate.opsForHash().multiGet(key, fields);
    }

    /**
     * @param key     String
     * @param hashKey String
     * @param value   String
     */
    public void strHPut(String key, String hashKey, String value) {
        stringRedisTemplate.opsForHash().put(key, hashKey, value);
    }

    /**
     * @param key  String
     * @param maps Map<String, String>
     */
    public void strHPutAll(String key, Map<String, String> maps) {
        stringRedisTemplate.opsForHash().putAll(key, maps);
    }

    /**
     * 仅当hashKey不存在时才设置
     *
     * @param key     String
     * @param hashKey String
     * @param value   String
     * @return Boolean
     */
    public Boolean strHPutIfAbsent(String key, String hashKey, String value) {
        return stringRedisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
    }

    /**
     * 删除一个或多个哈希表字段
     *
     * @param key    String
     * @param fields Object...
     * @return Long
     */
    public Long strHDelete(String key, Object... fields) {
        return stringRedisTemplate.opsForHash().delete(key, fields);
    }

    /**
     * 查看哈希表 key 中，指定的字段是否存在
     *
     * @param key   String
     * @param field String
     * @return boolean
     */
    public boolean strHExists(String key, String field) {
        return stringRedisTemplate.opsForHash().hasKey(key, field);
    }

    /**
     * 为哈希表 key 中的指定字段的整数值加上增量 increment
     *
     * @param key       String
     * @param field     Object
     * @param increment long
     * @return Long
     */
    public Long strHIncrBy(String key, Object field, long increment) {
        return stringRedisTemplate.opsForHash().increment(key, field, increment);
    }

    /**
     * 为哈希表 key 中的指定字段的整数值加上增量 increment
     *
     * @param key   String
     * @param field Object
     * @param delta double
     * @return Double
     */
    public Double strHIncrByFloat(String key, Object field, double delta) {
        return stringRedisTemplate.opsForHash().increment(key, field, delta);
    }

    /**
     * 获取所有哈希表中的字段
     *
     * @param key String
     * @return Set<Object>
     */
    public Set<Object> strHKeys(String key) {
        return stringRedisTemplate.opsForHash().keys(key);
    }

    /**
     * 获取哈希表中字段的数量
     *
     * @param key String
     * @return Long
     */
    public Long strHSize(String key) {
        return stringRedisTemplate.opsForHash().size(key);
    }

    /**
     * 获取哈希表中所有值
     *
     * @param key String
     * @return List<Object>
     */
    public List<Object> strHValues(String key) {
        return stringRedisTemplate.opsForHash().values(key);
    }

    /**
     * 迭代哈希表中的键值对
     *
     * @param key     String
     * @param options ScanOptions
     * @return Cursor<Map.Entry < Object, Object>>
     */
    public Cursor<Map.Entry<Object, Object>> strHScan(String key, ScanOptions options) {
        return stringRedisTemplate.opsForHash().scan(key, options);
    }

    // ------------------------list相关操作---------------------------- //

    /**
     * 通过索引获取列表中的元素
     *
     * @param key   String
     * @param index long
     * @return String
     */
    public String strLIndex(String key, long index) {
        return stringRedisTemplate.opsForList().index(key, index);
    }

    /**
     * 获取列表指定范围内的元素
     *
     * @param key   String
     * @param start 开始位置, 0是开始位置
     * @param end   结束位置, -1返回所有
     * @return List<String>
     */
    public List<String> strLRange(String key, long start, long end) {
        return stringRedisTemplate.opsForList().range(key, start, end);
    }

    /**
     * 存储在list头部
     *
     * @param key   String
     * @param value String
     * @return Long
     */
    public Long strLLeftPush(String key, String value) {
        return stringRedisTemplate.opsForList().leftPush(key, value);
    }

    /**
     * @param key   String
     * @param value String...
     * @return Long
     */
    public Long strLLeftPushAll(String key, String... value) {
        return stringRedisTemplate.opsForList().leftPushAll(key, value);
    }

    /**
     * @param key   String
     * @param value Collection<String>
     * @return Long
     */
    public Long strLLeftPushAll(String key, Collection<String> value) {
        return stringRedisTemplate.opsForList().leftPushAll(key, value);
    }

    /**
     * 当list存在的时候才加入
     *
     * @param key   String
     * @param value String
     * @return Long
     */
    public Long strLLeftPushIfPresent(String key, String value) {
        return stringRedisTemplate.opsForList().leftPushIfPresent(key, value);
    }

    /**
     * 如果pivot存在,再pivot前面添加
     *
     * @param key   String
     * @param pivot String
     * @param value String
     * @return Long
     */
    public Long strLLeftPush(String key, String pivot, String value) {
        return stringRedisTemplate.opsForList().leftPush(key, pivot, value);
    }

    /**
     * @param key   String
     * @param value String
     * @return Long
     */
    public Long strLRightPush(String key, String value) {
        return stringRedisTemplate.opsForList().rightPush(key, value);
    }

    /**
     * @param key   String
     * @param value String...
     * @return Long
     */
    public Long strLRightPushAll(String key, String... value) {
        return stringRedisTemplate.opsForList().rightPushAll(key, value);
    }

    /**
     * @param key   String
     * @param value Collection<String>
     * @return Long
     */
    public Long strLRightPushAll(String key, Collection<String> value) {
        return stringRedisTemplate.opsForList().rightPushAll(key, value);
    }

    /**
     * 为已存在的列表添加值
     *
     * @param key   String
     * @param value String
     * @return Long
     */
    public Long strLRightPushIfPresent(String key, String value) {
        return stringRedisTemplate.opsForList().rightPushIfPresent(key, value);
    }

    /**
     * 在pivot元素的右边添加值
     *
     * @param key   String
     * @param pivot String
     * @param value String
     * @return Long
     */
    public Long strLRightPush(String key, String pivot, String value) {
        return stringRedisTemplate.opsForList().rightPush(key, pivot, value);
    }

    /**
     * 通过索引设置列表元素的值
     *
     * @param key   String
     * @param index 位置
     * @param value String
     */
    public void strLSet(String key, long index, String value) {
        stringRedisTemplate.opsForList().set(key, index, value);
    }

    /**
     * 移出并获取列表的第一个元素
     *
     * @param key String
     * @return 删除的元素
     */
    public String strLLeftPop(String key) {
        return stringRedisTemplate.opsForList().leftPop(key);
    }

    /**
     * 移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
     *
     * @param key     String
     * @param timeout 等待时间
     * @param unit    时间单位
     * @return 删除的元素
     */
    public String strLbLeftPop(String key, long timeout, TimeUnit unit) {
        return stringRedisTemplate.opsForList().leftPop(key, timeout, unit);
    }

    /**
     * 移除并获取列表最后一个元素
     *
     * @param key String
     * @return 删除的元素
     */
    public String strLRightPop(String key) {
        return stringRedisTemplate.opsForList().rightPop(key);
    }

    /**
     * 移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
     *
     * @param key     String
     * @param timeout 等待时间
     * @param unit    时间单位
     * @return String
     */
    public String strLbRightPop(String key, long timeout, TimeUnit unit) {
        return stringRedisTemplate.opsForList().rightPop(key, timeout, unit);
    }

    /**
     * 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
     *
     * @param sourceKey      String
     * @param destinationKey String
     * @return String
     */
    public String strLRightPopAndLeftPush(String sourceKey, String destinationKey) {
        return stringRedisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
                destinationKey);
    }

    /**
     * 从列表中弹出一个值，将弹出的元素插入到另外一个列表中并返回它； 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
     *
     * @param sourceKey      String
     * @param destinationKey String
     * @param timeout        long
     * @param unit           TimeUnit
     * @return String
     */
    public String strLbRightPopAndLeftPush(String sourceKey, String destinationKey,
                                           long timeout, TimeUnit unit) {
        return stringRedisTemplate.opsForList().rightPopAndLeftPush(sourceKey,
                destinationKey, timeout, unit);
    }

    /**
     * 删除集合中值等于value得元素
     *
     * @param key   String
     * @param index index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;
     *              index<0, 从尾部开始删除第一个值等于value的元素;
     * @param value String
     * @return Long
     */
    public Long strLRemove(String key, long index, String value) {
        return stringRedisTemplate.opsForList().remove(key, index, value);
    }

    /**
     * 裁剪list
     *
     * @param key   String
     * @param start long
     * @param end   long
     */
    public void strLTrim(String key, long start, long end) {
        stringRedisTemplate.opsForList().trim(key, start, end);
    }

    /**
     * 获取列表长度
     *
     * @param key String
     * @return Long
     */
    public Long strLLen(String key) {
        return stringRedisTemplate.opsForList().size(key);
    }

    // --------------------set相关操作-------------------------- //

    /**
     * set添加元素
     *
     * @param key    String
     * @param values String...
     * @return Long
     */
    public Long strSAdd(String key, String... values) {
        return stringRedisTemplate.opsForSet().add(key, values);
    }

    /**
     * set移除元素
     *
     * @param key    String
     * @param values Object...
     * @return Long
     */
    public Long strSRemove(String key, Object... values) {
        return stringRedisTemplate.opsForSet().remove(key, values);
    }

    /**
     * 移除并返回集合的一个随机元素
     *
     * @param key String
     * @return String
     */
    public String strSPop(String key) {
        return stringRedisTemplate.opsForSet().pop(key);
    }

    /**
     * 将元素value从一个集合移到另一个集合
     *
     * @param key     String
     * @param value   String
     * @param destKey String
     * @return Boolean
     */
    public Boolean strSMove(String key, String value, String destKey) {
        return stringRedisTemplate.opsForSet().move(key, value, destKey);
    }

    /**
     * 获取集合的大小
     *
     * @param key String
     * @return Long
     */
    public Long strSSize(String key) {
        return stringRedisTemplate.opsForSet().size(key);
    }

    /**
     * 判断集合是否包含value
     *
     * @param key   String
     * @param value Object
     * @return Boolean
     */
    public Boolean strSIsMember(String key, Object value) {
        return stringRedisTemplate.opsForSet().isMember(key, value);
    }

    /**
     * 获取两个集合的交集
     *
     * @param key      String
     * @param otherKey String
     * @return Set<String>
     */
    public Set<String> strSIntersect(String key, String otherKey) {
        return stringRedisTemplate.opsForSet().intersect(key, otherKey);
    }

    /**
     * 获取key集合与多个集合的交集
     *
     * @param key       String
     * @param otherKeys String
     * @return Set<String>
     */
    public Set<String> strSIntersect(String key, Collection<String> otherKeys) {
        return stringRedisTemplate.opsForSet().intersect(key, otherKeys);
    }

    /**
     * key集合与otherKey集合的交集存储到destKey集合中
     *
     * @param key      String
     * @param otherKey String
     * @param destKey  String
     * @return String
     */
    public Long strSIntersectAndStore(String key, String otherKey, String destKey) {
        return stringRedisTemplate.opsForSet().intersectAndStore(key, otherKey,
                destKey);
    }

    /**
     * key集合与多个集合的交集存储到destKey集合中
     *
     * @param key       String
     * @param otherKeys String
     * @param destKey   String
     * @return Long
     */
    public Long strSIntersectAndStore(String key, Collection<String> otherKeys,
                                      String destKey) {
        return stringRedisTemplate.opsForSet().intersectAndStore(key, otherKeys,
                destKey);
    }

    /**
     * 获取两个集合的并集
     *
     * @param key       String
     * @param otherKeys String
     * @return Set<String>
     */
    public Set<String> strSUnion(String key, String otherKeys) {
        return stringRedisTemplate.opsForSet().union(key, otherKeys);
    }

    /**
     * 获取key集合与多个集合的并集
     *
     * @param key       String
     * @param otherKeys String
     * @return Set<String>
     */
    public Set<String> strSUnion(String key, Collection<String> otherKeys) {
        return stringRedisTemplate.opsForSet().union(key, otherKeys);
    }

    /**
     * key集合与otherKey集合的并集存储到destKey中
     *
     * @param key      String
     * @param otherKey String
     * @param destKey  String
     * @return Long
     */
    public Long strSUnionAndStore(String key, String otherKey, String destKey) {
        return stringRedisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);
    }

    /**
     * key集合与多个集合的并集存储到destKey中
     *
     * @param key       String
     * @param otherKeys String
     * @param destKey   String
     * @return Long
     */
    public Long strSUnionAndStore(String key, Collection<String> otherKeys,
                                  String destKey) {
        return stringRedisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);
    }

    /**
     * 获取两个集合的差集
     *
     * @param key      String
     * @param otherKey String
     * @return Set<String>
     */
    public Set<String> strSDifference(String key, String otherKey) {
        return stringRedisTemplate.opsForSet().difference(key, otherKey);
    }

    /**
     * 获取key集合与多个集合的差集
     *
     * @param key       String
     * @param otherKeys Collection<String>
     * @return Set<String>
     */
    public Set<String> strSDifference(String key, Collection<String> otherKeys) {
        return stringRedisTemplate.opsForSet().difference(key, otherKeys);
    }

    /**
     * key集合与otherKey集合的差集存储到destKey中
     *
     * @param key      String
     * @param otherKey String
     * @param destKey  String
     * @return Long
     */
    public Long strSDifference(String key, String otherKey, String destKey) {
        return stringRedisTemplate.opsForSet().differenceAndStore(key, otherKey,
                destKey);
    }

    /**
     * key集合与多个集合的差集存储到destKey中
     *
     * @param key       String
     * @param otherKeys Collection<String>
     * @param destKey   String
     * @return Long
     */
    public Long strSDifference(String key, Collection<String> otherKeys,
                               String destKey) {
        return stringRedisTemplate.opsForSet().differenceAndStore(key, otherKeys,
                destKey);
    }

    /**
     * 获取集合所有元素
     *
     * @param key String
     * @return Set<String>
     */
    public Set<String> strSetMembers(String key) {
        return stringRedisTemplate.opsForSet().members(key);
    }

    /**
     * 随机获取集合中的一个元素
     *
     * @param key String
     * @return String
     */
    public String strSRandomMember(String key) {
        return stringRedisTemplate.opsForSet().randomMember(key);
    }

    /**
     * 随机获取集合中count个元素
     *
     * @param key   String
     * @param count long
     * @return List<String>
     */
    public List<String> strSRandomMembers(String key, long count) {
        return stringRedisTemplate.opsForSet().randomMembers(key, count);
    }

    /**
     * 随机获取集合中count个元素并且去除重复的
     *
     * @param key   String
     * @param count long
     * @return Set<String>
     */
    public Set<String> strSDistinctRandomMembers(String key, long count) {
        return stringRedisTemplate.opsForSet().distinctRandomMembers(key, count);
    }

    /**
     * @param key     String
     * @param options ScanOptions
     * @return Cursor<String>
     */
    public Cursor<String> strSScan(String key, ScanOptions options) {
        return stringRedisTemplate.opsForSet().scan(key, options);
    }

    // ------------------zSet相关操作--------------------------------//

    /**
     * 添加元素,有序集合是按照元素的score值由小到大排列
     *
     * @param key   String
     * @param value String
     * @param score double
     * @return Boolean
     */
    public Boolean strZAdd(String key, String value, double score) {
        return stringRedisTemplate.opsForZSet().add(key, value, score);
    }

    /**
     * @param key    String
     * @param values Set<TypedTuple<String>>
     * @return Long
     */
    public Long strZAdd(String key, Set<ZSetOperations.TypedTuple<String>> values) {
        return stringRedisTemplate.opsForZSet().add(key, values);
    }

    /**
     * @param key    String
     * @param values Object...
     * @return Long
     */
    public Long strZRemove(String key, Object... values) {
        return stringRedisTemplate.opsForZSet().remove(key, values);
    }

    /**
     * 增加元素的score值，并返回增加后的值
     *
     * @param key   String
     * @param value String
     * @param delta double
     * @return Double
     */
    public Double strZIncrementScore(String key, String value, double delta) {
        return stringRedisTemplate.opsForZSet().incrementScore(key, value, delta);
    }

    /**
     * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列
     *
     * @param key   String
     * @param value Object
     * @return 0表示第一位
     */
    public Long strZRank(String key, Object value) {
        return stringRedisTemplate.opsForZSet().rank(key, value);
    }

    /**
     * 返回元素在集合的排名,按元素的score值由大到小排列
     *
     * @param key   String
     * @param value Object
     * @return Long
     */
    public Long strZReverseRank(String key, Object value) {
        return stringRedisTemplate.opsForZSet().reverseRank(key, value);
    }

    /**
     * 获取集合的元素, 从小到大排序
     *
     * @param key   String
     * @param start 开始位置
     * @param end   结束位置, -1查询所有
     * @return Set<String>
     */
    public Set<String> strZRange(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().range(key, start, end);
    }

    /**
     * 获取集合元素, 并且把score值也获取
     *
     * @param key   String
     * @param start long
     * @param end   long
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public Set<ZSetOperations.TypedTuple<String>> strZRangeWithScores(String key, long start,
                                                                      long end) {
        return stringRedisTemplate.opsForZSet().rangeWithScores(key, start, end);
    }

    /**
     * 根据Score值查询集合元素
     *
     * @param key String
     * @param min 最小值
     * @param max 最大值
     * @return Set<String>
     */
    public Set<String> strZRangeByScore(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().rangeByScore(key, min, max);
    }

    /**
     * 根据Score值查询集合元素, 从小到大排序
     *
     * @param key String
     * @param min 最小值
     * @param max 最大值
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public Set<ZSetOperations.TypedTuple<String>> strZRangeByScoreWithScores(String key,
                                                                             double min, double max) {
        return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);
    }

    /**
     * @param key   String
     * @param min   double
     * @param max   double
     * @param start long
     * @param end   long
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public Set<ZSetOperations.TypedTuple<String>> strZRangeByScoreWithScores(String key,
                                                                             double min, double max, long start, long end) {
        return stringRedisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,
                start, end);
    }

    /**
     * 获取集合的元素, 从大到小排序
     *
     * @param key   String
     * @param start long
     * @param end   long
     * @return Set<String>
     */
    public Set<String> strZReverseRange(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().reverseRange(key, start, end);
    }

    /**
     * 获取集合的元素, 从大到小排序, 并返回score值
     *
     * @param key   String
     * @param start long
     * @param end   long
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public Set<ZSetOperations.TypedTuple<String>> strZReverseRangeWithScores(String key,
                                                                             long start, long end) {
        return stringRedisTemplate.opsForZSet().reverseRangeWithScores(key, start,
                end);
    }

    /**
     * 根据Score值查询集合元素, 从大到小排序
     *
     * @param key String
     * @param min double
     * @param max double
     * @return Set<String>
     */
    public Set<String> strZReverseRangeByScore(String key, double min,
                                               double max) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, min, max);
    }

    /**
     * 根据Score值查询集合元素, 从大到小排序
     *
     * @param key String
     * @param min double
     * @param max double
     * @return Set<ZSetOperations.TypedTuple < String>>
     */
    public Set<ZSetOperations.TypedTuple<String>> strZReverseRangeByScoreWithScores(
            String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,
                min, max);
    }

    /**
     * @param key   String
     * @param min   double
     * @param max   double
     * @param start long
     * @param end   long
     * @return Set<String>
     */
    public Set<String> strZReverseRangeByScore(String key, double min,
                                               double max, long start, long end) {
        return stringRedisTemplate.opsForZSet().reverseRangeByScore(key, min, max,
                start, end);
    }

    /**
     * 根据score值获取集合元素数量
     *
     * @param key String
     * @param min double
     * @param max double
     * @return Long
     */
    public Long strZCount(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().count(key, min, max);
    }

    /**
     * 获取集合大小
     *
     * @param key String
     * @return Long
     */
    public Long strZSize(String key) {
        return stringRedisTemplate.opsForZSet().size(key);
    }

    /**
     * 获取集合大小
     *
     * @param key String
     * @return Long
     */
    public Long strZCard(String key) {
        return stringRedisTemplate.opsForZSet().zCard(key);
    }

    /**
     * 获取集合中value元素的score值
     *
     * @param key   String
     * @param value Object
     * @return Double
     */
    public Double strZScore(String key, Object value) {
        return stringRedisTemplate.opsForZSet().score(key, value);
    }

    /**
     * 移除指定索引位置的成员
     *
     * @param key   String
     * @param start long
     * @param end   long
     * @return Long
     */
    public Long strZRemoveRange(String key, long start, long end) {
        return stringRedisTemplate.opsForZSet().removeRange(key, start, end);
    }

    /**
     * 根据指定的score值的范围来移除成员
     *
     * @param key String
     * @param min double
     * @param max double
     * @return Long
     */
    public Long strZRemoveRangeByScore(String key, double min, double max) {
        return stringRedisTemplate.opsForZSet().removeRangeByScore(key, min, max);
    }

    /**
     * 获取key和otherKey的并集并存储在destKey中
     *
     * @param key      String
     * @param otherKey String
     * @param destKey  String
     * @return Long
     */
    public Long strZUnionAndStore(String key, String otherKey, String destKey) {
        return stringRedisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);
    }

    /**
     * @param key       String
     * @param otherKeys Collection<String>
     * @param destKey   String
     * @return Long
     */
    public Long strZUnionAndStore(String key, Collection<String> otherKeys,
                                  String destKey) {
        return stringRedisTemplate.opsForZSet()
                .unionAndStore(key, otherKeys, destKey);
    }

    /**
     * 交集
     *
     * @param key      String
     * @param otherKey String
     * @param destKey  String
     * @return Long
     */
    public Long strZIntersectAndStore(String key, String otherKey,
                                      String destKey) {
        return stringRedisTemplate.opsForZSet().intersectAndStore(key, otherKey,
                destKey);
    }

    /**
     * 交集
     *
     * @param key       String
     * @param otherKeys Collection<String>
     * @param destKey   String
     * @return Long
     */
    public Long strZIntersectAndStore(String key, Collection<String> otherKeys,
                                      String destKey) {
        return stringRedisTemplate.opsForZSet().intersectAndStore(key, otherKeys,
                destKey);
    }

    /**
     * @param key     String
     * @param options ScanOptions
     * @return Cursor<ZSetOperations.TypedTuple < String>>
     */
    public Cursor<ZSetOperations.TypedTuple<String>> strZScan(String key, ScanOptions options) {
        return stringRedisTemplate.opsForZSet().scan(key, options);
    }

}
